LL userspace: enable cross-core DP pipelines - #11397

Pass the message payload to the component IDC message handlers as an
argument, instead of fetching it from the per-core IDC payload area,
which is kernel memory.

Add idc_cmd_user() to let user-space threads (with CONFIG_SOF_USERSPACE_LL)
process component messages, sent from another core, with a payload
in user-accessible memory. Only the messages, which can originate from
the user-space IPC and LL threads, are supported.

LL modules on a core different from their pipeline core aren't
supported with user-space LL, so fail the prepare instead of trying
to set up an LL task for them.

Signed-off-by: Kai Vehmanen <kai.vehmanen@linux.intel.com>

comp_ipc4_get_attribute_remote() allocates the buffer for the remote
core to fill with rzalloc(), which takes a spinlock and fails in user
mode. With CONFIG_SOF_USERSPACE_LL it's called from user-space threads
and the buffer is filled by the user-space IPC thread of the remote
core, so allocate it from the coherent LL user heap instead.

Signed-off-by: Kai Vehmanen <kai.vehmanen@linux.intel.com>

With CONFIG_SOF_USERSPACE_LL, ipc_pipeline_module_free() takes the LL
scheduler lock of the core of the first module in the pipeline. That
is supposed to be the pipeline core, but a module can be on another
core (e.g. an offloaded DP module). Freeing such a remote module is
done on its core, where ipc_comp_free() takes the LL lock of that core,
which would deadlock, if it's the lock taken here.

Pass the pipeline core to ipc_pipeline_module_free() and lock that.

Signed-off-by: Kai Vehmanen <kai.vehmanen@linux.intel.com>

Cross-core binding was rejected at build time with
CONFIG_SOF_USERSPACE_LL. Implement the LL blocking for it:

The user-space LL thread holds its scheduler lock for the whole LL
cycle, so taking the LL lock of a core both blocks its next cycle and
waits for the current one to finish. ll_block() / ll_unblock() now take
the two modules and lock the cores of both modules and of their
pipelines, in ascending order to avoid deadlocks. The remote bind /
unbind requests are sent with the locks held, so ll_block() first
reserves the cross-core request slots of the other cores.
ll_wait_finished_on_core() doesn't need to send an IDC anymore.

pipeline_connect() / pipeline_disconnect() asserted the LL lock of the
buffer core. Cross-core buffers always belong to the primary core,
which isn't locked for e.g. a bind between cores 1 and 2, nor when
ipc_pipeline_module_free() disconnects a DP module on core 0 in a
pipeline on core 1. The modified lists are walked by the LL thread of
the pipeline core, so assert the lock of that core instead.

struct pipeline is in cached memory of the pipeline core, so its core
field can be stale on other cores, e.g. on the primary core, which
processes cross-core binds. Record the pipeline core in the coherent
comp_dev, in the new ipc_config.ppl_core, and read it with
comp_ppl_core().

The remote parts of the bind (get_attribute, bind, unbind) go through
idc_send_msg(), which forwards them to the user-space IPC thread of
the remote core.

The domain block / unblock in zephyr_domain.c uses a mutex and a
condition variable, embedded in user memory, and isn't used with
user-space LL, so don't build it then.

Signed-off-by: Kai Vehmanen <kai.vehmanen@linux.intel.com>

With CONFIG_CROSS_CORE_STREAM and CONFIG_SOF_USERSPACE_LL, a DP module
on a different core than its pipeline can now be bound and operated
across cores. With user-space LL, keep rejecting only LL modules on
another core than their pipeline. Such an LL module would need its own
LL task on that core, which is only set up by the kernel-mode IDC
handlers.

comp_buffer_connect() marked a component shared only when the buffer
is on another core. Cross-core buffers always belong to the primary
core, so e.g. a DP module on core 0 in a pipeline on core 1 was never
marked shared, and its operations, called on the pipeline core, were
run there instead of on core 0. Also mark a component shared, if it's
on another core than its pipeline.

The buffers to such a DP module must be shared even for a bind between
modules on the same core: the LL thread of the pipeline core copies the
data between the buffer and the queue of the DP module. Mark the buffers
shared, if the cores of the modules and of their pipelines differ. The
buffer core still depends only on whether the bind is cross-core.

Signed-off-by: Kai Vehmanen <kai.vehmanen@linux.intel.com>

Cross-core streams are now supported with user-space LL. Stop
disabling CONFIG_CROSS_CORE_STREAM in the LL user-space overlay.

This allows e.g. the compressed playback topology, which runs the
decoder (DP) on core 1, bound to the host copier on core 0.

The overlay is used by all ACE3.x and newer targets (e.g. PTL, WCL,
NVL) built with os_linux_overlay.conf. Tested on PTL.

Signed-off-by: Kai Vehmanen <kai.vehmanen@linux.intel.com>